// 本文件由gen_static_data_code生成
// 请遵照提示添加修改！！！

{{$TableName := .Name}}
{{$TableRawName := .RawName}}

package {{.Package}}

import (
    "fmt"
	"log"
	"io/ioutil"
	"math"
	"path/filepath"
	"time"

	jsoniter "github.com/json-iterator/go"
)

//////////////////////////////////////////////////////////////////////////////////////////////////
// TODO 添加头部扩展代码
//<Head>{{.GetExtendContent "Head"}}//</Head>
//////////////////////////////////////////////////////////////////////////////////////////////////

var _ = fmt.Printf
var _ = time.Now
var _ = math.MaxInt32

{{if .Comment}}// {{.Comment}}{{end}}
type {{.Name}} struct {
    {{range .Fields}}{{.RawName}} {{.Type}}{{if .Comment}}// {{.Comment}}{{end}}
	{{end}}
	//////////////////////////////////////////////////////////////////////////////////////////////////
	// TODO 添加结构体扩展字段
	//<StructExtend>{{.GetExtendContent "StructExtend"}}//</StructExtend>
	//////////////////////////////////////////////////////////////////////////////////////////////////
}

func New{{.Name}}() *{{.Name}} {
	sd := &{{.Name}}{}
	//////////////////////////////////////////////////////////////////////////////////////////////////
	// TODO 添加结构体New代码
	//<StructNew>{{.GetExtendContent "StructNew"}}//</StructNew>
	//////////////////////////////////////////////////////////////////////////////////////////////////
	return sd
}

{{range .Fields}}
{{if .Comment}}// {{.Comment}}{{end}}
func (sd {{$TableName}}) {{.Name}}() {{.Type}} {
    return sd.{{.RawName}}
}
{{end}}

func (sd {{.Name}}) Clone() *{{.Name}} {
    n := New{{.Name}}()
    *n = sd
	//////////////////////////////////////////////////////////////////////////////////////////////////
	// TODO 添加结构体Clone代码
	//<StructClone>{{.GetExtendContent "StructClone"}}//</StructClone>
	//////////////////////////////////////////////////////////////////////////////////////////////////
    return n
}

{{if .Attributes}}
//////////////////////////////////////////////////////////////////////////////////////////////////////
{{if .Comment}}// {{.Comment}}全局属性{{end}}
type {{.Name}}Global struct {
    {{range .Attributes}}{{.RawName}} {{.Type}}{{if .Comment}}// {{.Comment}}{{end}}
	{{end}}
}
{{range .Attributes}}
{{if .Comment}}// {{.Comment}}{{end}}
func (g {{$TableName}}Global) {{.Name}}() {{.Type}} {
    return g.{{.RawName}}
}
{{end}}
{{end}}

//////////////////////////////////////////////////////////////////////////////////////////////////////
type {{.Name}}Manager struct {
	Datas []*{{.Name}}
	{{if .Attributes}} Global {{.Name}}Global {{end}}
	size int
	//////////////////////////////////////////////////////////////////////////////////////////////////
	{{if .UniqueIndexes}}{{range .UniqueIndexes}}by{{.Name}} map[{{.Type}}]*{{$TableName}} // UniqueIndex
	{{end}}{{end}}
	//////////////////////////////////////////////////////////////////////////////////////////////////
    {{if .NormalIndexes}}{{range .NormalIndexes}}by{{.Name}} map[{{.Type}}][]*{{$TableName}} // NormalIndex
    {{end}}{{end}}
	//////////////////////////////////////////////////////////////////////////////////////////////////
    // TODO 添加manager扩展字段
	//<ManagerExtend>{{.GetExtendContent "ManagerExtend"}}//</ManagerExtend>
	//////////////////////////////////////////////////////////////////////////////////////////////////
}

func new{{.Name}}Manager() *{{.Name}}Manager {
	mgr := &{{.Name}}Manager{
		Datas: []*{{.Name}}{},
		{{if .UniqueIndexes}}{{range .UniqueIndexes}}by{{.Name}}: map[{{.Type}}]*{{$TableName}}{},{{end}}{{end}}
        {{if .NormalIndexes}}{{range .NormalIndexes}}by{{.Name}}: map[{{.Type}}][]*{{$TableName}}{},{{end}}{{end}}
	}

	//////////////////////////////////////////////////////////////////////////////////////////////////
    // TODO 添加manager的New代码
	//<ManagerNew>{{.GetExtendContent "ManagerNew"}}//</ManagerNew>
	//////////////////////////////////////////////////////////////////////////////////////////////////

	return mgr
}

func (mgr *{{.Name}}Manager) load(path string) (success bool) {
	success = true

	absPath, err := filepath.Abs(path)
	if err != nil {
		log.Printf("获取[%s]的绝对路径失败, %s\n", path, err)
		success = false
		return false
	}

	bs, err := ioutil.ReadFile(absPath)
    if err != nil {
		log.Printf("读取[%s]的内容失败, %s\n", path, err)
		success = false
        return
    }

    err = jsoniter.Unmarshal(bs, mgr)
    if err != nil {
		log.Printf("解析[%s]失败, %s\n", path, err)
		success = false
        return
    }

    mgr.size = len(mgr.Datas)

    //////////////////////////////////////////////////////////////////////////////////////////////////
    // TODO 添加manager加载前代码
    //<ManagerBeforeLoad>{{.GetExtendContent "ManagerBeforeLoad"}}//</ManagerBeforeLoad>
    //////////////////////////////////////////////////////////////////////////////////////////////////
	for i, d := range mgr.Datas {
        //////////////////////////////////////////////////////////////////////////////////////////////////
        // TODO 添加结构体加载代码
        //<StructLoad>{{.GetExtendContent "StructLoad"}}//</StructLoad>
        //////////////////////////////////////////////////////////////////////////////////////////////////
        err = mgr.check(path, i+1, d)
        if err != nil {
            log.Println(err)
            success = false
            continue
        }
        {{if .UniqueIndexes}}{{range .UniqueIndexes}} mgr.by{{.Name}}[d.{{.RawName}}] = d
        {{end}}{{end}}
        {{if .NormalIndexes}}{{range .NormalIndexes}} mgr.by{{.Name}}[d.{{.RawName}}] = append( mgr.by{{.Name}}[d.{{.RawName}}], d)
        {{end}}{{end}}
	}
    //////////////////////////////////////////////////////////////////////////////////////////////////
    // TODO 添加manager加载后代码
    //<ManagerAfterLoad>{{.GetExtendContent "ManagerAfterLoad"}}//</ManagerAfterLoad>
    //////////////////////////////////////////////////////////////////////////////////////////////////

	return
}

func {{.Name}}Size() int {
	return {{.RawName}}Mgr.size
}

func (mgr {{.Name}}Manager) check(path string, row int, sd *{{.Name}}) error {
    {{if .UniqueIndexes}}{{range .UniqueIndexes}}if _, ok := {{$TableRawName}}Mgr.by{{.Name}}[sd.{{.RawName}}]; ok {
		return fmt.Errorf("[%s]第[%d]行的{{.RawName}}重复", path, row)
	}
	{{end}}{{end}}
	//////////////////////////////////////////////////////////////////////////////////////////////////
	// TODO 添加检查代码
	//<Check>{{.GetExtendContent "Check"}}//</Check>
	//////////////////////////////////////////////////////////////////////////////////////////////////
	return nil
}

func (mgr *{{.Name}}Manager) afterLoadAll(path string) (success bool) {
	success = true
	//////////////////////////////////////////////////////////////////////////////////////////////////
	// TODO 添加加载后处理代码
	//<AfterLoadAll>{{.GetExtendContent "AfterLoadAll"}}//</AfterLoadAll>
	//////////////////////////////////////////////////////////////////////////////////////////////////
	return
}

func (mgr *{{.Name}}Manager)each(f func(sd *{{.Name}}) (continued bool)) {
	for _, sd := range mgr.Datas {
		if !f(sd) {
			break
		}
	}
}

func (mgr *{{.Name}}Manager)findIf(f func(sd *{{.Name}}) (find bool)) *{{.Name}} {
	for _, sd := range mgr.Datas {
		if f(sd) {
			return sd
		}
	}
	return nil
}

func Each{{.Name}}(f func(sd {{.Name}}) (continued bool)) {
	for _, sd := range {{.RawName}}Mgr.Datas {
		if !f(*sd) {
			break
		}
	}
}

func Find{{.Name}}If(f func(sd {{.Name}}) bool) ({{.Name}}, bool) {
	for _, sd := range {{.RawName}}Mgr.Datas {
		if f(*sd) {
			return *sd, true
		}
	}
	return nil{{.Name}}, false
}

{{if .UniqueIndexes}}
{{range .UniqueIndexes}}
func Get{{$TableName}}By{{.Name}}({{.RawName}} {{.Type}}) ({{$TableName}}, bool) {
    temp, ok := {{$TableRawName}}Mgr.by{{.Name}}[{{.RawName}}]
    if !ok {
        return nil{{$TableName}}, false
    }
    return *temp, true
}
{{end}}
{{end}}

{{if .NormalIndexes}}
{{range .NormalIndexes}}
func Get{{$TableName}}By{{.Name}}({{.RawName}} {{.Type}}) (vs []{{$TableName}}, ok bool) {
    var ds []*{{$TableName}}
    ds, ok = {{$TableRawName}}Mgr.by{{.Name}}[{{.RawName}}]
    if !ok {
        return
    }
    for _, d := range ds {
       vs = append(vs, *d)
    }
    return
}

func Each{{$TableName}}By{{.Name}}({{.RawName}} {{.Type}}, fn func(d {{$TableName}}) (continued bool)) (bool) {
	ds, ok := {{$TableRawName}}Mgr.by{{.Name}}[{{.RawName}}]
	if !ok {
		return false
	}
	for _, d := range ds {
		if !fn(*d) {
			break
		}
	}
	return true
}
{{end}}
{{end}}

{{if .Attributes}}
func Get{{$TableName}}Global() {{$TableName}}Global {
    return {{$TableRawName}}Mgr.Global
}
{{end}}

//////////////////////////////////////////////////////////////////////////////////////////////////
// TODO 添加尾部扩展代码
//<Tail>{{.GetExtendContent "Tail"}}//</Tail>
//////////////////////////////////////////////////////////////////////////////////////////////////
